/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Controladores;

import Controladores.exceptions.IllegalOrphanException;
import Controladores.exceptions.NonexistentEntityException;
import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import Entidades.Tipocurso;
import Entidades.Cursoposible;
import java.util.ArrayList;
import java.util.Collection;
import Entidades.Asignacionseccioncurso;
import Entidades.Curso;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;

/**
 *
 * @author userlab05
 */
public class CursoJpaController implements Serializable {

    public CursoJpaController(EntityManagerFactory emf) {
        this.emf = emf;
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Curso curso) {
        if (curso.getCursoposibleCollection() == null) {
            curso.setCursoposibleCollection(new ArrayList<Cursoposible>());
        }
        if (curso.getAsignacionseccioncursoCollection() == null) {
            curso.setAsignacionseccioncursoCollection(new ArrayList<Asignacionseccioncurso>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Tipocurso tipoCursoidTipoCurso = curso.getTipoCursoidTipoCurso();
            if (tipoCursoidTipoCurso != null) {
                tipoCursoidTipoCurso = em.getReference(tipoCursoidTipoCurso.getClass(), tipoCursoidTipoCurso.getIdTipoCurso());
                curso.setTipoCursoidTipoCurso(tipoCursoidTipoCurso);
            }
            Collection<Cursoposible> attachedCursoposibleCollection = new ArrayList<Cursoposible>();
            for (Cursoposible cursoposibleCollectionCursoposibleToAttach : curso.getCursoposibleCollection()) {
                cursoposibleCollectionCursoposibleToAttach = em.getReference(cursoposibleCollectionCursoposibleToAttach.getClass(), cursoposibleCollectionCursoposibleToAttach.getIdCursoPosible());
                attachedCursoposibleCollection.add(cursoposibleCollectionCursoposibleToAttach);
            }
            curso.setCursoposibleCollection(attachedCursoposibleCollection);
            Collection<Asignacionseccioncurso> attachedAsignacionseccioncursoCollection = new ArrayList<Asignacionseccioncurso>();
            for (Asignacionseccioncurso asignacionseccioncursoCollectionAsignacionseccioncursoToAttach : curso.getAsignacionseccioncursoCollection()) {
                asignacionseccioncursoCollectionAsignacionseccioncursoToAttach = em.getReference(asignacionseccioncursoCollectionAsignacionseccioncursoToAttach.getClass(), asignacionseccioncursoCollectionAsignacionseccioncursoToAttach.getIdAsignacionSeccionCurso());
                attachedAsignacionseccioncursoCollection.add(asignacionseccioncursoCollectionAsignacionseccioncursoToAttach);
            }
            curso.setAsignacionseccioncursoCollection(attachedAsignacionseccioncursoCollection);
            em.persist(curso);
            if (tipoCursoidTipoCurso != null) {
                tipoCursoidTipoCurso.getCursoCollection().add(curso);
                tipoCursoidTipoCurso = em.merge(tipoCursoidTipoCurso);
            }
            for (Cursoposible cursoposibleCollectionCursoposible : curso.getCursoposibleCollection()) {
                Curso oldCursoidCursoOfCursoposibleCollectionCursoposible = cursoposibleCollectionCursoposible.getCursoidCurso();
                cursoposibleCollectionCursoposible.setCursoidCurso(curso);
                cursoposibleCollectionCursoposible = em.merge(cursoposibleCollectionCursoposible);
                if (oldCursoidCursoOfCursoposibleCollectionCursoposible != null) {
                    oldCursoidCursoOfCursoposibleCollectionCursoposible.getCursoposibleCollection().remove(cursoposibleCollectionCursoposible);
                    oldCursoidCursoOfCursoposibleCollectionCursoposible = em.merge(oldCursoidCursoOfCursoposibleCollectionCursoposible);
                }
            }
            for (Asignacionseccioncurso asignacionseccioncursoCollectionAsignacionseccioncurso : curso.getAsignacionseccioncursoCollection()) {
                Curso oldCursoidCursoOfAsignacionseccioncursoCollectionAsignacionseccioncurso = asignacionseccioncursoCollectionAsignacionseccioncurso.getCursoidCurso();
                asignacionseccioncursoCollectionAsignacionseccioncurso.setCursoidCurso(curso);
                asignacionseccioncursoCollectionAsignacionseccioncurso = em.merge(asignacionseccioncursoCollectionAsignacionseccioncurso);
                if (oldCursoidCursoOfAsignacionseccioncursoCollectionAsignacionseccioncurso != null) {
                    oldCursoidCursoOfAsignacionseccioncursoCollectionAsignacionseccioncurso.getAsignacionseccioncursoCollection().remove(asignacionseccioncursoCollectionAsignacionseccioncurso);
                    oldCursoidCursoOfAsignacionseccioncursoCollectionAsignacionseccioncurso = em.merge(oldCursoidCursoOfAsignacionseccioncursoCollectionAsignacionseccioncurso);
                }
            }
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Curso curso) throws IllegalOrphanException, NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Curso persistentCurso = em.find(Curso.class, curso.getIdCurso());
            Tipocurso tipoCursoidTipoCursoOld = persistentCurso.getTipoCursoidTipoCurso();
            Tipocurso tipoCursoidTipoCursoNew = curso.getTipoCursoidTipoCurso();
            Collection<Cursoposible> cursoposibleCollectionOld = persistentCurso.getCursoposibleCollection();
            Collection<Cursoposible> cursoposibleCollectionNew = curso.getCursoposibleCollection();
            Collection<Asignacionseccioncurso> asignacionseccioncursoCollectionOld = persistentCurso.getAsignacionseccioncursoCollection();
            Collection<Asignacionseccioncurso> asignacionseccioncursoCollectionNew = curso.getAsignacionseccioncursoCollection();
            List<String> illegalOrphanMessages = null;
            for (Cursoposible cursoposibleCollectionOldCursoposible : cursoposibleCollectionOld) {
                if (!cursoposibleCollectionNew.contains(cursoposibleCollectionOldCursoposible)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Cursoposible " + cursoposibleCollectionOldCursoposible + " since its cursoidCurso field is not nullable.");
                }
            }
            for (Asignacionseccioncurso asignacionseccioncursoCollectionOldAsignacionseccioncurso : asignacionseccioncursoCollectionOld) {
                if (!asignacionseccioncursoCollectionNew.contains(asignacionseccioncursoCollectionOldAsignacionseccioncurso)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Asignacionseccioncurso " + asignacionseccioncursoCollectionOldAsignacionseccioncurso + " since its cursoidCurso field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (tipoCursoidTipoCursoNew != null) {
                tipoCursoidTipoCursoNew = em.getReference(tipoCursoidTipoCursoNew.getClass(), tipoCursoidTipoCursoNew.getIdTipoCurso());
                curso.setTipoCursoidTipoCurso(tipoCursoidTipoCursoNew);
            }
            Collection<Cursoposible> attachedCursoposibleCollectionNew = new ArrayList<Cursoposible>();
            for (Cursoposible cursoposibleCollectionNewCursoposibleToAttach : cursoposibleCollectionNew) {
                cursoposibleCollectionNewCursoposibleToAttach = em.getReference(cursoposibleCollectionNewCursoposibleToAttach.getClass(), cursoposibleCollectionNewCursoposibleToAttach.getIdCursoPosible());
                attachedCursoposibleCollectionNew.add(cursoposibleCollectionNewCursoposibleToAttach);
            }
            cursoposibleCollectionNew = attachedCursoposibleCollectionNew;
            curso.setCursoposibleCollection(cursoposibleCollectionNew);
            Collection<Asignacionseccioncurso> attachedAsignacionseccioncursoCollectionNew = new ArrayList<Asignacionseccioncurso>();
            for (Asignacionseccioncurso asignacionseccioncursoCollectionNewAsignacionseccioncursoToAttach : asignacionseccioncursoCollectionNew) {
                asignacionseccioncursoCollectionNewAsignacionseccioncursoToAttach = em.getReference(asignacionseccioncursoCollectionNewAsignacionseccioncursoToAttach.getClass(), asignacionseccioncursoCollectionNewAsignacionseccioncursoToAttach.getIdAsignacionSeccionCurso());
                attachedAsignacionseccioncursoCollectionNew.add(asignacionseccioncursoCollectionNewAsignacionseccioncursoToAttach);
            }
            asignacionseccioncursoCollectionNew = attachedAsignacionseccioncursoCollectionNew;
            curso.setAsignacionseccioncursoCollection(asignacionseccioncursoCollectionNew);
            curso = em.merge(curso);
            if (tipoCursoidTipoCursoOld != null && !tipoCursoidTipoCursoOld.equals(tipoCursoidTipoCursoNew)) {
                tipoCursoidTipoCursoOld.getCursoCollection().remove(curso);
                tipoCursoidTipoCursoOld = em.merge(tipoCursoidTipoCursoOld);
            }
            if (tipoCursoidTipoCursoNew != null && !tipoCursoidTipoCursoNew.equals(tipoCursoidTipoCursoOld)) {
                tipoCursoidTipoCursoNew.getCursoCollection().add(curso);
                tipoCursoidTipoCursoNew = em.merge(tipoCursoidTipoCursoNew);
            }
            for (Cursoposible cursoposibleCollectionNewCursoposible : cursoposibleCollectionNew) {
                if (!cursoposibleCollectionOld.contains(cursoposibleCollectionNewCursoposible)) {
                    Curso oldCursoidCursoOfCursoposibleCollectionNewCursoposible = cursoposibleCollectionNewCursoposible.getCursoidCurso();
                    cursoposibleCollectionNewCursoposible.setCursoidCurso(curso);
                    cursoposibleCollectionNewCursoposible = em.merge(cursoposibleCollectionNewCursoposible);
                    if (oldCursoidCursoOfCursoposibleCollectionNewCursoposible != null && !oldCursoidCursoOfCursoposibleCollectionNewCursoposible.equals(curso)) {
                        oldCursoidCursoOfCursoposibleCollectionNewCursoposible.getCursoposibleCollection().remove(cursoposibleCollectionNewCursoposible);
                        oldCursoidCursoOfCursoposibleCollectionNewCursoposible = em.merge(oldCursoidCursoOfCursoposibleCollectionNewCursoposible);
                    }
                }
            }
            for (Asignacionseccioncurso asignacionseccioncursoCollectionNewAsignacionseccioncurso : asignacionseccioncursoCollectionNew) {
                if (!asignacionseccioncursoCollectionOld.contains(asignacionseccioncursoCollectionNewAsignacionseccioncurso)) {
                    Curso oldCursoidCursoOfAsignacionseccioncursoCollectionNewAsignacionseccioncurso = asignacionseccioncursoCollectionNewAsignacionseccioncurso.getCursoidCurso();
                    asignacionseccioncursoCollectionNewAsignacionseccioncurso.setCursoidCurso(curso);
                    asignacionseccioncursoCollectionNewAsignacionseccioncurso = em.merge(asignacionseccioncursoCollectionNewAsignacionseccioncurso);
                    if (oldCursoidCursoOfAsignacionseccioncursoCollectionNewAsignacionseccioncurso != null && !oldCursoidCursoOfAsignacionseccioncursoCollectionNewAsignacionseccioncurso.equals(curso)) {
                        oldCursoidCursoOfAsignacionseccioncursoCollectionNewAsignacionseccioncurso.getAsignacionseccioncursoCollection().remove(asignacionseccioncursoCollectionNewAsignacionseccioncurso);
                        oldCursoidCursoOfAsignacionseccioncursoCollectionNewAsignacionseccioncurso = em.merge(oldCursoidCursoOfAsignacionseccioncursoCollectionNewAsignacionseccioncurso);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = curso.getIdCurso();
                if (findCurso(id) == null) {
                    throw new NonexistentEntityException("The curso with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Curso curso;
            try {
                curso = em.getReference(Curso.class, id);
                curso.getIdCurso();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The curso with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            Collection<Cursoposible> cursoposibleCollectionOrphanCheck = curso.getCursoposibleCollection();
            for (Cursoposible cursoposibleCollectionOrphanCheckCursoposible : cursoposibleCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Curso (" + curso + ") cannot be destroyed since the Cursoposible " + cursoposibleCollectionOrphanCheckCursoposible + " in its cursoposibleCollection field has a non-nullable cursoidCurso field.");
            }
            Collection<Asignacionseccioncurso> asignacionseccioncursoCollectionOrphanCheck = curso.getAsignacionseccioncursoCollection();
            for (Asignacionseccioncurso asignacionseccioncursoCollectionOrphanCheckAsignacionseccioncurso : asignacionseccioncursoCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Curso (" + curso + ") cannot be destroyed since the Asignacionseccioncurso " + asignacionseccioncursoCollectionOrphanCheckAsignacionseccioncurso + " in its asignacionseccioncursoCollection field has a non-nullable cursoidCurso field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            Tipocurso tipoCursoidTipoCurso = curso.getTipoCursoidTipoCurso();
            if (tipoCursoidTipoCurso != null) {
                tipoCursoidTipoCurso.getCursoCollection().remove(curso);
                tipoCursoidTipoCurso = em.merge(tipoCursoidTipoCurso);
            }
            em.remove(curso);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Curso> findCursoEntities() {
        return findCursoEntities(true, -1, -1);
    }

    public List<Curso> findCursoEntities(int maxResults, int firstResult) {
        return findCursoEntities(false, maxResults, firstResult);
    }

    private List<Curso> findCursoEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Curso.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Curso findCurso(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Curso.class, id);
        } finally {
            em.close();
        }
    }

    public int getCursoCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Curso> rt = cq.from(Curso.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
